AttachmentEchoEndpoint.java

/**
 * Copyright 2015 Nortal Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language governing permissions and limitations under the
 * License.
 **/

package com.nortal.jroad.example.endpoints;

import java.io.IOException;

import javax.activation.DataHandler;
import javax.activation.DataSource;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import org.springframework.util.FileCopyUtils;

import com.nortal.jroad.annotation.XTeeService;
import com.nortal.jroad.endpoint.AbstractXTeeJAXBEndpoint;
import com.nortal.jroad.example.model.AttachmentEchoNest;
import com.nortal.jroad.example.model.AttachmentEchoRequest;
import com.nortal.jroad.example.model.AttachmentEchoResponse;
import com.nortal.jroad.jaxb.ByteArrayDataSource;

/**
 * Sample service endpoint, which supports binary attachments. Please refer to the PDF documentation on how to create
 * valid Schema (xsd) files. These attachments are sent as binary and are never converted to Base64. If you need Base64
 * conversion for legacy purposes, then you have to implement it yourself. This is not fully compliant with the X-tee
 * specification, but encoding large files to Base64 is a huge waste of resources. If you want to use Base64 encoding,
 * you can always send your attachments inline, since MTOM is disabled. It is however heavily detrimental to
 * performance.
 * 
 * @author Dmitri Danilkin
 */
@Component
@XTeeService(name = "AttachmentEcho", version = "v1", title = "Attachment echo endpoint")
public class AttachmentEchoEndpoint extends AbstractXTeeJAXBEndpoint<AttachmentEchoRequest> {
  private static Logger log = Logger.getLogger(AttachmentEchoEndpoint.class);

  @Override
  protected Class<AttachmentEchoRequest> getParingKehaClass() {
    // As incoming object's Element name is "keha", the query class must be
    // shown
    return AttachmentEchoRequest.class;
  }

  @Override
  protected AttachmentEchoResponse invokeBean(AttachmentEchoRequest requestBean) throws IOException {
    // Creation of a response object -- must correspond to
    // response type defined in XML Schema definition.
    AttachmentEchoResponse response = new AttachmentEchoResponse();

    // Create a temporary object to store our data
    byte[] data = null;

    // Logging
    log.info("Received attachment, type: " + requestBean.getNest().getAttachment().getContentType() + ", size: "
        + requestBean.getNest().getAttachment().getInputStream().available());
    // Using a Spring helper class we read an InputStream to a byte array.
    // In real situations you probably want to pass the InputStream around.
    data = FileCopyUtils.copyToByteArray(requestBean.getNest().getAttachment().getInputStream());

    /*
     * JAXB generates DataHandler type setters for attachments, so you need to find a way to get your data into a
     * DataHandler. The easiest way to accomplish this, is to create a DataSource. A DataSource used here only needs to
     * provide an InputStream and a content type. A simple DataSource, which takes a byte array and content-type in
     * string form is included. Usually you would use something like FileDataSource, UrlDataSource or you can easily
     * implement your own. All a DataSource basically does in this context is give an InputStream and a content type for
     * that InputStream. An alternative way is to define a DataContentHandler and pass an object+content type when
     * creating a DataHandler. This way you will have to implement a DataContentHandler and DataContentHandlerFactory,
     * however.
     */
    DataSource ds = new ByteArrayDataSource(requestBean.getNest().getAttachment().getContentType(), data);

    // Now we can easily construct a DataHandler and pass it to JAXB.
    // Converting it to an attachment is handled by the library.
    DataHandler dh = new DataHandler(ds);
    AttachmentEchoNest nest = new AttachmentEchoNest();
    nest.setAttachment(dh);
    response.setNest(nest);

    // Finally, we return the response object.
    return response;
  }
}